/**
 * 发布应用脚本
 */
const fs = require('fs-extra');
const path = require('path');
const chalk = require('chalk');
const ora = require('ora');
const { checkLogin } = require('./login');
const {buildApp} = require("./build-app");

// 工作目录
const WORK_DIR = process.cwd();

/**
 * 发布应用
 * @param {string} appDir 应用目录
 * @param {Object} options 发布选项
 * @returns {Promise<Object>} 发布结果
 */
async function publishApp(appDir, options = {}) {
  const {
    publishUrl,
    publishMethod = 'http'
  } = options;

  const spinner = ora('准备发布应用...').start();

  try {
    // 检查登录状态
    const token = await checkLogin();

    // 检查应用目录是否存在
    if (!fs.existsSync(appDir)) {
      throw new Error(`应用目录不存在: ${appDir}`);
    }

    // 检查应用配置
    const appConfigPath = path.join(appDir, 'app.json');
    if (!fs.existsSync(appConfigPath)) {
      throw new Error('应用配置文件不存在');
    }

    const appConfig = await fs.readJSON(appConfigPath);

    // 检查输出目录
    const buildOutDir = path.join(WORK_DIR, appConfig.package.buildOutDir);
    if (!fs.existsSync(buildOutDir)) {
      throw new Error(`buildOutDir目录不存在: ${buildOutDir}`);
    }

    // 检查应用包
    const zipPath = path.join(buildOutDir, `${appConfig.name}-${appConfig.version}.zip`);
    if (!fs.existsSync(zipPath)) {
      throw new Error(`应用包不存在`);
    }

    // 发布应用
    spinner.text = '发布应用...';
    switch (publishMethod) {
      case 'http':
        await publishViaHttp(zipPath, publishUrl, token);
        break;
      case 'ftp':
        await publishViaFtp(zipPath, publishUrl, token);
        break;
      case 'sftp':
        await publishViaSftp(zipPath, publishUrl, token);
        break;
      default:
        throw new Error(`不支持的发布方式: ${publishMethod}`);
    }

    spinner.succeed(`应用发布成功! 版本: ${appConfig.version}`);

    return {
      appDir,
      version: appConfig.version,
      publishUrl,
      publishMethod
    };
  } catch (err) {
    spinner.fail(`发布应用失败: ${err.message}`);
    throw err;
  }
}

/**
 * 通过HTTP发布
 * @param {string} filePath 文件路径
 * @param {string} url 发布地址
 * @param {string} token 认证令牌
 * @returns {Promise<void>}
 */
async function publishViaHttp(filePath, url, token) {
  try {
    // 创建 FormData
    const formData = new FormData();
    formData.append('file', fs.createReadStream(filePath));

    // 发送请求
    const response = await axios.post(url, formData, {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'multipart/form-data'
      }
    });

    if (response.status !== 200) {
      throw new Error(`发布失败: ${response.data.message || '未知错误'}`);
    }
  } catch (err) {
    throw new Error(`HTTP发布失败: ${err.message}`);
  }
}

/**
 * 通过FTP发布
 * @param {string} filePath 文件路径
 * @param {string} url 发布地址
 * @param {string} token 认证令牌
 * @returns {Promise<void>}
 */
async function publishViaFtp(filePath, url, token) {
  // TODO: 实现FTP发布
  throw new Error('FTP发布方式暂未实现');
}

/**
 * 通过SFTP发布
 * @param {string} filePath 文件路径
 * @param {string} url 发布地址
 * @param {string} token 认证令牌
 * @returns {Promise<void>}
 */
async function publishViaSftp(filePath, url, token) {
  // TODO: 实现SFTP发布
  throw new Error('SFTP发布方式暂未实现');
}

/**
 * 交互式发布应用
 * @returns {Promise<Object>} 发布结果
 */
async function publishAppInteractive() {
  try {
    if (!fs.existsSync(path.join(WORK_DIR, 'app.json'))) {
      throw new Error('当前目录下未找到app.json文件');
    }

    const appDir = WORK_DIR;
    const publishMethod = 'http'
    const publishUrl = ''

    // 选择发布方式
    // const { publishMethod } = await inquirer.prompt([
    //   {
    //     type: 'list',
    //     name: 'publishMethod',
    //     message: '选择发布方式:',
    //     choices: [
    //       { name: 'HTTP', value: 'http' },
    //       { name: 'FTP', value: 'ftp' },
    //       { name: 'SFTP', value: 'sftp' }
    //     ],
    //     default: 'http'
    //   }
    // ]);

    // 配置发布地址
    // const { publishUrl } = await inquirer.prompt([
    //   {
    //     type: 'input',
    //     name: 'publishUrl',
    //     message: '发布地址:',
    //     validate: (input) => input.trim() !== '' ? true : '请输入发布地址'
    //   }
    // ]);

    // 打包应用
    await buildApp(appDir)

    // 发布应用
    return await publishApp(appDir, {
      publishUrl,
      publishMethod
    });
  } catch (err) {
    console.error(chalk.red(`错误: ${err.message}`));
    throw err;
  }
}

module.exports = {
  publishApp,
  publishAppInteractive
};
